A Conceptual Architecture for Enabling Future Self-Adaptive Service Systems

Dynamic integration methods for unknown data sources and services at system design time are currently primarily driven by technological standards. Hence, little emphasis is being placed on integration methods. However, the combination of heterogeneous data sources and services offered by devices across domains is hard to standardize. In this paper, we will shed light on the interplay of self-adaptive system architectures as well as bottom-up, incremental integration methods relying on formal knowledge bases. An incremental integration method has direct influences on both the system architecture itself and the way these systems are engineered and operated during design and runtime. Our findings are evaluated in the context of a case study that uses an adapted bus architecture including two tool prototypes. In addition, we illustrate conceptually how control loops such as MAPE-K can be enriched with machine-readable integration knowledge

Knowledge-driven architecture composition

Service interoperability for embedded devices is a mandatory feature for dynamically changing Internet-of-Things and Industry 4.0 software platforms. Service interoperability is achieved on a technical, syntactic, and semantic level. If service interoperability is achieved on all layers, plug and play functionality known from USB storage sticks or printer drivers becomes feasible. As a result, micro batch size production, individualized automation solution, or job order production become affordable. However, interoperability at the semantic layer is still a problem for the maturing class of IoT systems. Current solutions to achieve semantic integration of IoT devices’ heterogeneous services include standards, machine-understandable service descriptions, and the implementation of software adapters. Standardization bodies such as the VDMA tackle the problem by providing a reference software architecture and an information meta model for building up domain standards. For instance, the universal machine technology interface (UMATI) facilitates the data exchange between machines, components, installations, and their integration into a customerand user-specific IT ecosystem for mechanical engineering and plant construction worldwide. Automated component integration approaches fill the gap of software interfaces that are not relying on a global standard. These approaches translate required into provided software interfaces based on the needed architectural styles (e.g., client-server, layered, publish-subscribe, or cloud-based) using additional component descriptions. Interoperability at the semantic layer is achieved by relying on a shared domain vocabulary (e.g., an ontology) and service description (e.g., SAWSDL) used by all devices involved. If these service descriptions are available and machine-understandable knowledge of how to integrate software components on the functional and behavioral level is available, plug and play scenarios are feasible. Both standards and formal service descriptions cannot be applied effectively to IoT systems as they rely on the assumption that the semantic domain is completely known when they are noted down. This assumption is hard to believe as an increasing number of decentralized developed and connected IoT devices will exist (i.e., 30.73 billion in 2020 and 75.44 billion in 2025). If standards are applied in IoT systems, they must be updated continuously, so they contain the most recent domain knowledge agreed upon centrally and ahead of application. Although formal descriptions of concrete integration contexts can happen in a decentralized manner, they still rely on the assumption that the knowledge once noted down is complete. Hence, if an interoperable service from a new device is available that has not been considered in the initial integration context, the formal descriptions must be updated continuously. Both the formalization effort and keeping standards up to date result in too much additional engineering effort. Consequently, practitioners rely on implementing software adapters manually. However, this dull solution hardly scales with the increasing number of IoT devices. In this work, we introduce a novel engineering method that explicitly allows for an incomplete semantic domain description without losing the ability for automated IoT system integration. Dropping the completeness claim requires the management of incomplete integration knowledge. By sharing integration knowledge centrally, we assist the system integrator in automating software adapter generation. In addition to existing approaches, we enable semantic integration for services by making integration knowledge reusable. We empirically show with students that integration effort can be lowered in a home automation context

MergePoint: A Graphical Web-App for merging HTTP-Endpoints and IoT-Platform Models

More and more devices are connected to Internet of Things Platforms in various application domains. The resulting device integration effort is moderated by the concrete integration syntax and the technical abilities of the device integrator. Therefore, researchers from various communities have been investigating and designing component coupling architectures to achieve interoperability for more than 30 years. Emerging Smart Home scenarios challenges classical integration approaches as no single formal integration standard exists. In this paper we introduce a reference architecture called MergePoint that automates HTTP-Endpoint integration with smart home platforms such as openHAB in a plug-and-play manner. Based on a prototypical system implementation, our empirical evaluation demonstrates that average integration time can be reduced by 78% and average tool usability score is increased by 65% compared to textual integration approaches. MergePoint can serve as a reference implementation for practitioners that want to automate the integration between HTTP-Endpoints and IoT Platform Models

Executing model-based software development for embedded I4.0 devices properly

Technical interoperability in “Industrie 4.0” scenarios is currently being achieved by standards such as OPC UA. Such standards allow operators to use a common communication interface for heterogeneous production devices. However, production flexibility (e.g. self-configuration or dynamic self-adaptation) can only be achieved if system structure and engineering processes change. At the moment, traditional engineering processes for embedded systems generate communication interfaces from software. This stands in stark contrast to component-based software engineering approaches. In this paper, we introduce a tool-based software engineering approach that puts models back at the core of embedded system development. This approach enables flexible production scenarios by bringing together process-oriented software development and operator-oriented interface construction

Next steps in knowledge-driven architecture composition

Software architecture knowledge management has itself positioned as a mature research stream over the last years. Superficially, architectural knowledge management is about documenting design and design decisions. In software-intensive systems, a concrete application scenario of architectural knowledge management deals with the question whether a provided functionality fits a required functionality. To automate the underlying integrationprocess, various research communities came up with, for example, interface definition languages and service matchers. However, formalizing the semantics ofa software interface is in practice currently regarded as a price too high to pay. In this paper, we provide the status of our incremental case-based integration method that aims at reducing the effort for formalizing integration knowledge without losing the ability to compose software components based on interface semantics automatically

A mapping language for IoT device descriptions

Component models for IoT devices regain popularity. As more and more devices must be semantically connected within IoT platforms, digital abstractions for these devices are needed. For this purpose, textual device descriptions which encapsulate device-specific characteristics are a suitable candidate. Such component descriptions formally describe a device’s information model as well as the offered functionality in a standardized way. However, smart IoT platforms mainly solve user goals by composing various IoT devices in a suitable manner. Current IoT descriptions, such as Eclipse Vorto do not address this need at all. In this paper, we introduce a formal mapping language that allows to capture functional interaction semantics already during device integration time. Our evaluation shows that only few mapping elements are needed to define functional mappings between operations as well as to capture the underlying communication pattern

Knowledge-driven architecture composition

Automating component coupling has been around for various decades. In fact, in the last few years’ interface and component matching progress seems not to be regarded as a hot-topic in research. However, reappearing paradigms such as decentralized and flexible production scenarios are again in need for automated system coupling. This is mainly due to the increasing number of heterogeneous devices. Building upon existing component integration research, this PhD project introduces case-based reasoning techniques for formalizing integration knowledge to overcome standardization requirements. As a consequence, integration knowledge becomes reusable

Knowledge-driven architecture composition: Assisting the system integrator to reuse integration knowledge

Semantic interoperability for web services is still a problem. Although decentralized solutions such as describing the integration context with a formal mapping language or using a web service description language exist, practitioners rely on implementing software adapters manually. For IoT and Web of Things systems, current scientific solutions fall short as changing them, once defined, requires strenuous effort. However, devices and thus, their interfaces change often in this class of system. This paper tackles the barrier of high formalization effort for mappings between required and provided interfaces. Therefore, we apply and evaluate a novel integration method for web service choreography. Our empirical experiment shows that this method lowers the integration time and number of errors by assisting the system integrator to reuse integration knowledge from previous integration cases